#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <tuple>
#include <utility>
#include <functional>
#include <set>
#include <map>
#include <bitset>
#include <list>
#include <iomanip>

using namespace std;
using ll = long long;
using ULL = unsigned long long;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vl = std::vector<ll>;
using vb = std::vector<bool>;
using db = double;
using vdb = std::vector<db>;
using qlg= std::priority_queue<ll, vl, std::greater<ll> > ; //ascending
using qll= std::priority_queue<ll, vl, std::less<ll> > ; // descending
using qdg= std::priority_queue<db, vdb, std::greater<db> > ; //ascending
using qdl= std::priority_queue<db, vdb, std::less<db> > ; // descending
template<class T>
using vv = std::vector<std::vector<T> >;


#define REPL(i, n) for (ll i = 0; i < (ll)(n); i++)
#define FORL(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define REP(i, n) FORL(i, 0, n)

#define MREP(i, n) for (ll i= (ll)(n)-1; i>=0; i-- )
#define MFOR(i, a, b) for (ll i = (ll)(b)-1; i >= (ll)(a); i--)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rreps(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define bit(n) (1LL << (n))
#define INF pow(10, 10)

ll search_lower(ll val, ll div)
{
    // ans*div <= val, (ans+1)*div > val
    // 10600 -> 1, -10600 -> -2
    ll candidate = val/div;
    while(candidate*div < val) { candidate ++; }
    while(candidate*div > val) { candidate --; }
    return candidate;
}

ll search_upper(ll val, ll div)
{
    // ans*div >= val, (ans-1)*div < val
    // 10600 -> 2, -10600 -> -1
    ll candidate = val/div;
    while(candidate*div > val) { candidate --; }
    while(candidate*div < val) { candidate ++; }
    return candidate;
}

ll calcmaxy(ll val, ll div)
{
    if (val >= 0 || val % 10000 == 0) {
        val /= 10000;
    } else {
        val = val / 10000 - 1;
    }
    return val;
}

ll calcminy(ll val, ll div)
{
    if (val <= 0 || val % 10000 == 0) {
        val /= 10000;
    } else {
        val = val / 10000 + 1;
    }
    return val;
}

bool judge_within_circle(ll r, ll x_c, ll y_c, ll x, ll y)
{
    return pow(x-x_c, 2)+pow(y-y_c, 2) <= pow(r, 2);
}



void solve(ll X, ll Y, ll R) {

    ll res = 0;
    for (ll x = -200000 * 10000; x <= 200000 * 10000; x += 10000) {
        if (x < X - R || X + R < x) continue;
        ll maxY = Y + sqrt(R * R - (X - x) * (X - x)) + 5;
        while ((maxY - Y) * (maxY - Y) + (X - x) * (X - x) > R * R) maxY--;
        ll minY = Y - sqrt(R * R - (X - x) * (X - x)) - 5;
        while ((minY - Y) * (minY - Y) + (X - x) * (X - x) > R * R) minY++;
        if (maxY >= 0 || maxY % 10000 == 0) {
            maxY /= 10000;
        } else {
            maxY = maxY / 10000 - 1;
        }
        if (minY <= 0 || minY % 10000 == 0) {
            minY /= 10000;
        } else {
            minY = minY / 10000 + 1;
        }
        if (minY > maxY) continue;
        res += maxY - minY + 1;
    }

    cout << res << endl;
}


int main(void)
{

    double eps = pow(10, -8);
    double xin, yin, rin;
    string Str;
    cin >> xin >> yin >> rin;
    ll x, y, r;
    x = round( xin*pow(10, 4) ); y = round( yin*pow(10, 4) ); r = round( rin*pow(10, 4) );

    solve(x, y, r);

    /*
    x = round( xin*pow(10, 4) ); y = round( yin*pow(10, 4) ); r = round( rin*pow(10, 4) );

    ll ymax = floor( 1.0*(y+r)/pow(10, 4) );
    ll ymin = ceil( 1.0*(y-r)/pow(10, 4) );

    ll N_c = 0;
    ll Rsqre = pow(r, 2);
    //cout << ymin << " " << ymax << endl;
    ll Max = pow(10, 9)*2;
    ll div = pow(10, 4);
    for(ll Y= -Max; Y<= Max; Y+= pow(10, 4) )
    {
        if( Y < y-r || Y > y+r ) continue;
        // ULL Ysqre = pow( (ULL) abs(Y-y), 2.0);
        ll X = (ll) sqrt( (r-(Y-y) ) * (r+Y-y) );

        // upper: 10600 -> 10000, -10600 -> -20000
        // lower: 10600 -> 20000, -10600 -> -10000, -10000 -> -10000
        // ll Xmax = (ll) (x+X)/pow(10, 4) ;
        ll Xmax = X+x+5;
        while( ! judge_within_circle(r, x, y, Xmax, Y) ) Xmax --;
        ll Xmin = x-X-5;
        while( ! judge_within_circle(r, x, y, Xmin, Y) ) Xmin ++;
        Xmax = search_lower(x+X, div);
        Xmin = search_upper(x-X, div);
        // if(Xmin*pow(10, 4) < x-X ) Xmin ++;
        ll Np = max(Xmax-Xmin+1, 0LL);
        N_c += Np;
        //cout << Y << " " << X << " " << Np << endl;
    }
    // (ll) -1/100 -> 0, 1/100 -> 0
    */

    /*
    cout << "Max "
    << search_lower(10600, div) << " " << search_lower(10000, div) << " " << search_lower(9000, div) << " "
    << search_lower(0, div) << "    "
    << search_lower(-10600, div) << " " << search_lower(-10000, div) << " " << search_lower(-9000, div) <<endl;

    cout <<"Min "
    << search_upper(10600, div) << " " << search_upper(10000, div) << " " << search_upper(9000, div) << " "
    << search_upper(0, div) << "    "
    << search_upper(-10600, div) << " " << search_upper(-10000, div) << " " << search_upper(-9000, div)<< endl;


    cout << "Max2 "
    << calcmaxy(10600, div) << " " << calcmaxy(10000, div) << " " << calcmaxy(9000, div) << " "
    << calcmaxy(0, div) << "    "
    << calcmaxy(-10600, div) << " " << calcmaxy(-10000, div) << " " << calcmaxy(-9000, div) <<endl;

    cout << "Min2 "
    << calcminy(10600, div) << " " << calcminy(10000, div) << " " << calcminy(9000, div) << " "
    << calcminy(0, div) << "    "
    << calcminy(-10600, div) << " " << calcminy(-10000, div) << " " << calcminy(-9000, div) <<endl;
    */

    /*
    cout << N_c << endl;
    */

    return 0;
}
